﻿using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using 坦克大战.Properties;

namespace 坦克大战
{
    class 游戏管理者
    {

        private static List<不移动物体> 墙集合 = new List<不移动物体>();
        private static List<不移动物体> 钢铁集合 = new List<不移动物体>();
        private static List<敌人坦克> 敌人坦克集合 = new List<敌人坦克>();
        private static List<子弹> 子弹集合 = new List<子弹>();
        private static List<爆炸> 爆炸集合 = new List<爆炸>();


        private static 不移动物体 boss;
        private static 我的坦克 w我的坦克;
        private static int 敌人计数 = 60;
        private static int 敌人生成速度 = 60;
        private static Point[] points = new Point[3];
        private static Object _子弹锁 = new object();
        public static void Start()
        {

            points[0].X = 0;
            points[0].Y = 0;
            points[1].X = 7 * 30;
            points[1].Y = 0;
            points[2].X = 14 * 30;
            points[2].Y = 0;

        }

        public static void Update()
        {
            foreach (var item in 墙集合)
            {
                item.Update();
            }
            foreach (var item in 钢铁集合)
            {
                item.Update();
            }


            foreach (var item in 敌人坦克集合)
            {
                item.Update();
            }
            检测子弹销毁();
            lock (_子弹锁)
            {
                foreach (var item in 子弹集合)
                {
                    item.Update();
                }
            }
            检测爆炸销毁(); 
            foreach (var item in 爆炸集合)
            {
                item.Update();
            }


            boss.Update();
            w我的坦克.Update();

            敌人生成();

         
        }
        public static void 检测子弹销毁()
        {
            List<子弹> zds = new List<子弹>();
            foreach (var item in 子弹集合)
            {
                if (item.是否销毁)
                {
                    zds.Add(item);
                }
            }
            foreach (var item in zds)
            {
                子弹集合.Remove(item);
                    
              
            }

        } public static void 检测爆炸销毁()
        {
            List<爆炸> zds = new List<爆炸>();
            foreach (var item in 爆炸集合)
            {
                if (item.b是否销毁)
                {
                    zds.Add(item);
                }
            }
            foreach (var item in zds)
            {
                爆炸集合.Remove(item);
                    
              
            }

        }

        public static void 敌人生成()
        {
            敌人计数++;
            if (敌人计数 < 敌人生成速度) return;

            
            Random rd = new Random();
            int index = rd.Next(0, 3);
            Point p = points[index];

            int i = rd.Next(1, 5);
            switch (i)
            {
                case 1:
                    创造敌人坦克1(p.X, p.Y);
                    break;
                case 2:
                    创造敌人坦克2(p.X, p.Y);
                    break;
                case 3:
                    创造敌人坦克3(p.X, p.Y);
                    break;
                case 4:
                    创造敌人坦克4(p.X, p.Y);
                    break;
                default:
                    break;
            }

            敌人计数 = 0;
        }
        public static void 创建子弹(int x, int y, 方向 方向, Tag Tag)
        {

            子弹 z = new 子弹(x, y, 10, 方向, Tag);
            lock (_子弹锁)
            {
                子弹集合.Add(z);
            }

        }

        public static void 创建爆炸(int x, int y)
        {

            爆炸 b = new 爆炸(x, y);

            爆炸集合.Add(b);
         

        }


        public static void 销毁子弹(子弹 z)
        {
    
                子弹集合.Remove(z);
        

        }
        public static void 销毁墙(不移动物体 墙)
        {
            墙集合.Remove(墙);
        }
            public static void 销毁敌人坦克(敌人坦克 d)
        {
            敌人坦克集合.Remove(d);
        }

        public static 敌人坦克 是否碰撞敌人(Rectangle r)
        {
            foreach (var item in 敌人坦克集合)
            {
                if (item.获得矩形().IntersectsWith(r))
                {
                   
                    return item;
                }
            }
            return null;
        }
    
        public static void 创造敌人坦克1(int x, int y)
        {
            敌人坦克 d = new 敌人坦克(x, y, 3, Resources.GrayUp,
                Resources.GrayDown, Resources.GrayLeft, Resources.GrayRight);
            敌人坦克集合.Add(d);
        }
        public static void 创造敌人坦克2(int x, int y)
        {
            敌人坦克 d = new 敌人坦克(x, y, 1, Resources.GreenUp,
                Resources.GreenDown, Resources.GreenLeft, Resources.GreenRight);
            敌人坦克集合.Add(d);
        }
        public static void 创造敌人坦克3(int x, int y)
        {
            敌人坦克 d = new 敌人坦克(x, y, 8, Resources.QuickUp,
                Resources.QuickDown, Resources.QuickLeft, Resources.QuickRight);
            敌人坦克集合.Add(d);
        }
        public static void 创造敌人坦克4(int x, int y)
        {
            敌人坦克 d = new 敌人坦克(x, y, 1, Resources.SlowUp,
                Resources.SlowDown, Resources.SlowLeft, Resources.SlowRight);
            敌人坦克集合.Add(d);
        }


        //public static void 绘制我的坦克()
        //{

        //    w我的坦克.画自身();

        //}
        //public static void 绘制地图()
        //{
        //    foreach (var item in 墙集合)
        //    {
        //        item.画自身();
        //    }
        //    foreach (var item in 钢铁集合)
        //    {
        //        item.画自身();
        //    }
        //    boss.画自身();

        //}

        public static void 创建地图()
        {
            创建墙(1, 1, 5, Resources.wall, 墙集合);
            创建墙(3, 1, 5, Resources.wall, 墙集合);
            创建墙(5, 1, 4, Resources.wall, 墙集合);
            创建墙(7, 1, 3, Resources.wall, 墙集合);
            创建墙(9, 1, 4, Resources.wall, 墙集合);
            创建墙(11, 1, 5, Resources.wall, 墙集合);
            创建墙(13, 1, 5, Resources.wall, 墙集合);

            创建墙(7, 5, 1, Resources.steel, 钢铁集合);

            创建墙(0, 7, 1, Resources.steel, 钢铁集合);


            创建墙(2, 7, 1, Resources.wall, 墙集合);
            创建墙(3, 7, 1, Resources.wall, 墙集合);
            创建墙(4, 7, 1, Resources.wall, 墙集合);
            创建墙(6, 7, 1, Resources.wall, 墙集合);
            创建墙(7, 6, 2, Resources.wall, 墙集合);
            创建墙(8, 7, 1, Resources.wall, 墙集合);
            创建墙(10, 7, 1, Resources.wall, 墙集合);
            创建墙(11, 7, 1, Resources.wall, 墙集合);
            创建墙(12, 7, 1, Resources.wall, 墙集合);

            创建墙(14, 7, 1, Resources.steel, 钢铁集合);


            创建墙(1, 9, 5, Resources.wall, 墙集合);
            创建墙(3, 9, 5, Resources.wall, 墙集合);
            创建墙(5, 9, 3, Resources.wall, 墙集合);

            创建墙(6, 10, 1, Resources.wall, 墙集合);
            创建墙(7, 10, 2, Resources.wall, 墙集合);
            创建墙(8, 10, 1, Resources.wall, 墙集合);

            创建墙(9, 9, 3, Resources.wall, 墙集合);
            创建墙(11, 9, 5, Resources.wall, 墙集合);
            创建墙(13, 9, 5, Resources.wall, 墙集合);

            创建墙(6, 13, 2, Resources.wall, 墙集合);
            创建墙(7, 13, 4, Resources.wall, 墙集合);
            创建墙(8, 13, 2, Resources.wall, 墙集合);

            创建boss(7, 14, Resources.Boss);


            //创建墙(5, 9, 4, Resources.wall, 墙集合);

        }
        public static void 创建boss(int x, int y, Image 材质)
        {
            int x像素位置 = x * 30;
            int y像素位置 = y * 30;
            boss = new 不移动物体(x像素位置, y像素位置, 材质);
        }
        public static void 创建墙(int x, int y, int 数目, Image 材质, List<不移动物体> 墙集合)
        {
            int x像素位置 = x * 30;
            int y像素位置 = y * 30;
            for (int i = y像素位置; i < y像素位置 + 数目 * 30; i += 15)
            {
                不移动物体 wall01 = new 不移动物体(x像素位置, i, 材质);
                不移动物体 wall02 = new 不移动物体(x像素位置 + 15, i, 材质);
                墙集合.Add(wall01);
                墙集合.Add(wall02);
            }

        }

        public static int 速度 = 10;
        public static void 创建我的坦克()
        {
            int x像素位置 = 5 * 30;
            int y像素位置 = 14 * 30;
            w我的坦克 = new 我的坦克(x像素位置, y像素位置, 速度);

        }

        public static void 按键按下(KeyEventArgs e)
        {
            w我的坦克.按键按下(e);
        }
        public static void 按键抬起(KeyEventArgs e)
        {
            w我的坦克.按键抬起(e);

        }

        public static 不移动物体 是否碰撞墙(Rectangle r)
        {
            foreach (var item in 墙集合)
            {
                if (item.获得矩形().IntersectsWith(r))
                {
                  
                   
                    return item;
                }
            }
            return null;
        }
        public static 不移动物体 是否碰撞钢铁(Rectangle r)
        {
            foreach (var item in 钢铁集合)
            {
                if (item.获得矩形().IntersectsWith(r))
                {
                    
                    return item;
                }
            }
            return null;
        }
        public static bool 是否碰撞boss(Rectangle r)
        {
            if (boss.获得矩形().IntersectsWith(r))
            {
                游戏音效.播放开始音效();
                return true;
            }

            return false;
        }
        public static 我的坦克 是否碰撞我的坦克(Rectangle r)
        {
            if (w我的坦克.获得矩形().IntersectsWith(r))
            {
               
                return w我的坦克;
            }

            return null;
        }
    }
}
